/**********************************************************************
                         Collection  -  description
                             -------------------
    debut                :  11 oct. 2009
    copyright            : (C) 2009 par Binome 3310
*************************************************************************/

//---- Realisation de la classe <Collection> (fichier Collection.cpp) ---

//--------------------------------------------------------------- INCLUDE

//-------------------------------------------------------- Include systeme
#include <iostream>
using namespace std;

//------------------------------------------------------ Include personnel
#include "Collection.h"

//------------------------------------------------------------- Constantes
//----------------------------------------------------------------- PUBLIC

//----------------------------------------------------- Methodes publiques
// type Collection::Méthode (liste des paramètres)
// Algorithme
//
//{
//} //------ Fin de Méthode

	void Collection::Display()
	// Algorithme :
	//
	{
		if(nbElements != 0)
		{
			for(int i = 0; i < nbElements; i++)
			{
				cout << "Indice dans la collection: " << i << ", Valeur:" << " " << collectionArray[i] << endl;
			}
		}
		else
		{
			cout << "La collection est vide" << endl;
		}
	} //------ Fin de Méthode

	codeRetour Collection::Add(float newElement)
	// Algorithme :
	//
	{
		if(size > nbElements)
		{
			collectionArray[nbElements] = newElement;
			nbElements++;
			return OK;
		}
		else
		{
			return FULL;
		}
	} //------ Fin de Méthode

	codeRetour Collection::Add(Collection &newCollection)
	// Algorithme :
	//	SI il y a assez de place pour que la collection puisse accueillir tous les éléments de la seconde collection
	//		-> Insertion des éléments de la seconde collection dans la collection après ceux déjà présents
	//	SINON
	//		-> Création d'un tableau dynamique temporaire tel que : Taille_tableau_temporaire = Nbre_éléments_première_collection
	//		-> Copie des éléments de la première collection dans le tableau temporaire
	//		-> Suppression du tableau initial contenant les éléments de la première collection
	//		-> Recréation du tableau initial tel que : Taille_init_tab = Nbre_élements_première_collection + Nbre_élément_seconde_collection
	//		-> Copie des éléments du tableau temporaire dans le nouveau tableau
	//		-> Copie des éléments de la seconde collection dans le nouveau tableau
	//		-> Suppression du tableau temporaire
	//		-> Modification de la capacité de la collection telle que : Capacité_collection = Nbre_élements_première_collection + Nbre_éléments_seconde_collection
	//	FIN_SI
	//	Mofication du nombre d'éléments de la collection tel que : Nbre_éléments_collection = Nbre_élements_première_collection + Nbre_éléments_seconde_collection
	//	Retourne OK
	//
	{
		int nbNewElements = newCollection.Count();
		float newElement;

		if(size - nbElements > nbNewElements)
		{
			// Insertion des éléments de la seconde collection dans la collection après ceux déjà présents
			for(int i = 0; i < nbNewElements; i++)
			{
				if(newCollection.GetItem(i, newElement) == OK)
				{
					collectionArray[i + nbElements] = newElement;
				}
			}
		}
		else
		{
			// Création d'un tableau dynamique temporaire
			float* tempCollection = new float [nbElements];

			// Copie des éléments de la collection dans le tableau temporaire
			for(int i = 0; i < nbElements; i++)
			{
				tempCollection[i] = collectionArray [i];
			}

			// Suppression du tableau initial
			delete collectionArray;

			// Recrétion du tableau initial
			collectionArray = new float [nbElements + nbNewElements];

			// Copie des éléments du tableau temporaire dans le nouveau tableau
			for(int i = 0; i < nbElements; i++)
			{
				collectionArray[i] = tempCollection[i];
			}

			// Copie des éléments de la seconde collection dans le nouveu tableau
			for(int i = 0; i < nbNewElements; i++)
			{
				if(newCollection.GetItem(i, newElement) == OK)
				{
					collectionArray[i + nbElements] = newElement;
				}
			}

			// Suppression du tableau temporaire
			delete tempCollection;

			// Modification de la capacité de la collection
			size = nbElements + nbNewElements;
		}

		// Modification du nombre d'éléments présents dans la collection
		nbElements = nbElements + nbNewElements;

		// Retourne OK
		return OK;
	} //------ Fin de Méthode

	codeRetour Collection::Resize(int newCollectionSize)
	// Algorithme :
	//	SI La nouvelle capacité est différente de l'ancienne capacité
	//		-> Création d'un tableau dynamique temporaire tel que : Taille_tableau_temporaire = Nouvelle_capacité
	//		-> Copie des éléments du tableau inital contenant tous les éléments de la collection dans le tableau temporaire
	//			Seuls les éléments dont l'indice est inférieur à la nouvelle capacité sont copiés
	//		-> Suppression du tableau initial
	// 		-> Recréation du tableau initial tel que Taille_init_tab = Nouvelle_capacité
	//		-> Copie des éléments du tableau temporaire dans le nouveau tableau
	//		-> Suppression du tableau temporaire
	//		SI la nouvelle capacité de la collection est inférieur au nombre d'élément présent dans la collection avant redimensionnement
	//			-> Modification du nombre d'éléments de la collection tel que : Nbre_éléments_collection = Nouvelle_capacité
	//		SINON
	//			-> Pas de modication du nombre d'éléments de la collection
	//		FIN_SI
	//			-> Modification de la capacité de la collection telle que : Capacité_collection = Nouvelle_capacité
	//	FIN_SI
	//	Retourne OK
	//
	{
		if (newCollectionSize != size)
		{
			// Création d'un tableau dynamique temporaire
			float *tempCollection = new float [newCollectionSize];

			// Copie des éléments du tableau initial dans le tableau temporaire
			for(int i = 0; i < min(newCollectionSize, nbElements); i++)
			{
				tempCollection[i] = collectionArray[i];
			}

			// Supression du tableau initial
			delete collectionArray;

			// Recrétion du tableau temporaire
			collectionArray = new float [newCollectionSize];

			// Copie des éléments du tableau temporaire dans le nouveau tableau
			for(int i = 0; i < min(newCollectionSize, nbElements); i++)
			{
				collectionArray[i] = tempCollection[i];
			}

			// Suppression du tableau temporaire
			delete tempCollection;

			// Modification si necessaire du nombre d'éléments de la collection
			if (newCollectionSize < nbElements)
			{
				nbElements = newCollectionSize;
			}

			// Modification de la taille de la collection
			size = newCollectionSize;
		}

		// Retourne OK
		return OK;

	} //------ Fin de Méthode

	codeRetour Collection::Remove(int elementArraySize, int *elementArray)
	// Algorithme :
	//	-> Création d'un tableau temporaire tel que : Taille_tableau_temporaire = Nbre_élément_collection
	//	SI le nombre d'éléments de la collection est non nul
	//		POUR chaque élément du tableau initial contenant les éléments de la collection
	//			SI l'indice de l'élément n'est pas dans le tableau pointé par le paramètre elementArray
	//				-> Copie de l'élément dans le tableau temporaire
	//			FIN_SI
	//		FIN_POUR
	//		-> Suppression du tableau initial
	//		-> Recréation du tableau initial tel que Taille_init_tab = Nbre_éléments_collection - Nbre_éléments_supprimés
	//		-> Copie des éléments du tableau temporaire dans le nouveau tableau
	//		-> Suppression du tableau temporaire
	//		-> Modification de la capacité de la collection telle que : Capacité_collection = Nbre_éléments_collection - Nbre_éléments_supprimés
	//		SI Nbre_éléments_à_supprimés < Nbre_éléments_supprimés
	//			-> Modification du nombre d'éléments de la collection tel que Nbre_éléments_collection = Capacité_collection
	//			-> Retourne WARNING
	//		SINON
	//			-> Modification du nombre d'éléments de la collection tel que Nbre_éléments_collection = Capacité_collection
	//			-> Retourne OK
	//		FIN_SI
	//	SINON
	//		-> Retourne EMPTY
	//	FIN_SI
	//
	{
		// Création d'un tableau dynamique temporaire
		float *tempCollection = new float [nbElements];

		int index = 0;
		int j = 0;

		if(nbElements != 0)
		{
			// Copie des éléments du tableau initial qui ne doivent pas être supprimés dans le tableau temporaire
			for(int i = 0; i < nbElements; ++i)
			{
				while(j < elementArraySize - 1 && i != elementArray[j])
				{
					j++;
				}

				if(i != elementArray[j])
				{
					tempCollection[index] = collectionArray[i];
					++index;
				}

				j = 0;
			}

			// Suppression du tableau initial
			delete collectionArray;

			// Recréation du tableau initial
			collectionArray = new float [index];

			// Copie des éléments du tableau temporaire dans le nouveau tableau
			for(int i = 0; i < index ; i++)
			{
				collectionArray[i] = tempCollection[i];
			}

			// Suppression du tableau initial
			delete tempCollection;

			// Modification de la taille de la collection
			size = index;

			if (nbElements - elementArraySize < index)
			{
				// Modification du nombre d'élément de la collection et retourne WARNING
				nbElements = index;
				return WARNING;
			}
			else
			{
				// Modification du nombre d'élément de la collection et retourne OK
				nbElements = index;
				return OK;
			}
		}
		else
		{
			// Retourne EMPTY si la collection est vide
			return EMPTY;
		}
	} //------ Fin de Méthode

	int Collection::Count()
	// Algorithme :
	//
	{
		return nbElements;
	} //------ Fin de Méthode

	int Collection::Capacity()
	// Algorithme :
	//
	{
		return size;
	} //------ Fin de Méthode

	codeRetour Collection::GetItem(int index, float &element)
	// Algorithme :
	//
	{
		if(index < nbElements)
		{
			element = collectionArray[index];
			return OK;
		}
		else
		{
			return ERROR; // Element absent du tableau
		}
	} //------ Fin de Méthode

//-------------------------------------------------- Surcharge d'opérateur

//-------------------------------------------- Constructeurs - destructeur

	Collection::Collection(int collectionSize)
	// Algorithme :
	//
	{
		#ifdef MAP
			cout << "Appel au constructeur de <Collection>" << endl;
		#endif

		collectionArray = new float [collectionSize];
		size = collectionSize;
		nbElements = 0;
	} //------ Fin de Collection

	Collection::Collection(int collectionSize, int elementArraySize, float *elementArray)
	// Algorithme :
	//
	{
		#ifdef MAP
			cout << "Appel au constructeur de <Collection>" << endl;
		#endif

		if(collectionSize >= elementArraySize)
		{
			collectionArray = new float [collectionSize];
			size = collectionSize;
			nbElements = elementArraySize;

			for(int i = 0; i < elementArraySize; i++)
			{
				collectionArray[i] = elementArray[i];
			}
		}
	} //------ Fin de Collection

	Collection::~Collection()
	{
		#ifdef MAP
		cout << "Appel au destructeur de <Collection>" << endl;
		#endif

		delete collectionArray;
	} //------ Fin de ~Collection

//------------------------------------------------------------------ PRIVE

//----------------------------------------------------- Méthodes protégées
